home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / diskBoot.OpenProm / RCS / fs.c,v < prev    next >
Text File  |  1991-01-06  |  18KB  |  864 lines
  1. head     1.12;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.12
  10. date     91.01.06.00.18.12;  author dlong;  state Exp;
  11. branches ;
  12. next     1.11;
  13.  
  14. 1.11
  15. date     90.11.27.11.17.26;  author jhh;  state Exp;
  16. branches ;
  17. next     1.10;
  18.  
  19. 1.10
  20. date     90.07.17.15.42.24;  author mendel;  state Exp;
  21. branches ;
  22. next     1.9;
  23.  
  24. 1.9
  25. date     89.06.16.08.29.57;  author brent;  state Exp;
  26. branches ;
  27. next     1.8;
  28.  
  29. 1.8
  30. date     89.01.06.08.14.31;  author brent;  state Exp;
  31. branches ;
  32. next     1.7;
  33.  
  34. 1.7
  35. date     87.05.19.12.14.02;  author brent;  state Exp;
  36. branches ;
  37. next     1.6;
  38.  
  39. 1.6
  40. date     87.05.11.11.16.35;  author brent;  state Exp;
  41. branches ;
  42. next     1.5;
  43.  
  44. 1.5
  45. date     87.05.08.17.44.41;  author brent;  state Exp;
  46. branches ;
  47. next     1.4;
  48.  
  49. 1.4
  50. date     86.07.24.11.32.59;  author brent;  state Exp;
  51. branches ;
  52. next     1.3;
  53.  
  54. 1.3
  55. date     86.07.21.09.35.02;  author brent;  state Exp;
  56. branches ;
  57. next     1.2;
  58.  
  59. 1.2
  60. date     86.07.18.11.58.21;  author nelson;  state Exp;
  61. branches ;
  62. next     1.1;
  63.  
  64. 1.1
  65. date     86.07.18.09.32.17;  author brent;  state Exp;
  66. branches ;
  67. next     ;
  68.  
  69.  
  70. desc
  71. @Boot time filesystem utilities
  72. @
  73.  
  74.  
  75. 1.12
  76. log
  77. @changed FS_FD_MAGIC to FSDM_FD_MAGIC
  78. @
  79. text
  80. @/* fs.c -
  81.  *
  82.  *    General filesystem support.
  83.  *
  84.  * Copyright (C) 1985 Regents of the University of California
  85.  * All rights reserved.
  86.  */
  87.  
  88. #ifdef notdef
  89. static char rcsid[] = "$Header: /sprite/src/boot/sunprom.dlong.new/RCS/fs.c,v 1.11 90/11/27 11:17:26 jhh Exp Locker: dlong $ SPRITE (Berkeley)";
  90. #endif not lint
  91.  
  92. #include "sprite.h"
  93. #include "fsBoot.h"
  94. #include "machMon.h"
  95. #include "ofs.h"
  96.  
  97. /*
  98.  * For non-block aligned reads.
  99.  */
  100. char    readBuffer[FS_BLOCK_SIZE];
  101.  
  102. /*
  103.  * For lookup
  104.  */
  105. static char    component[FS_MAX_NAME_LENGTH];
  106.  
  107. /*
  108.  * Forward declarations.
  109.  */
  110. void FsGetFileDesc();
  111. void FsInitFileHandle();
  112.  
  113. /*
  114.  * ----------------------------------------------------------------------------
  115.  *
  116.  * Open --
  117.  *
  118.  *    Open a file.  This does a simple lookup (based on the kernel's
  119.  *    FsLocalLookup) and creates a handle for the file.
  120.  *
  121.  * Results:
  122.  *    SUCCESS or a return code from various sub-operations.
  123.  *
  124.  * Side effects:
  125.  *    Calls malloc
  126.  *
  127.  * ----------------------------------------------------------------------------
  128.  */
  129.  
  130. ReturnStatus
  131. Open(fileName, useFlags, permissions, handlePtrPtr)
  132.     char *fileName;
  133.     int useFlags;
  134.     int permissions;
  135.     Fsio_FileIOHandle     **handlePtrPtr;
  136. {
  137.     register ReturnStatus status;
  138.     Fsio_FileIOHandle *curHandlePtr;
  139.     register char *curCharPtr;
  140.     register char *componentPtr;
  141.     register int index;
  142.  
  143.     curCharPtr = fileName;
  144.     while(*curCharPtr == '/') {
  145.     curCharPtr++;
  146.     }
  147.     curHandlePtr = fsRootHandlePtr;
  148.  
  149.     while (*curCharPtr != '\0') {
  150.     if (curHandlePtr->descPtr->fileType != FS_DIRECTORY) {
  151.         return(FS_NOT_DIRECTORY);
  152.     }
  153.         /*
  154.          * Get the next component.
  155.          */
  156.         index = 0;
  157.     componentPtr = component;
  158.         while (*curCharPtr != '/' && *curCharPtr != '\0') {
  159.             *componentPtr++ = *curCharPtr++;
  160.         }
  161.         *componentPtr = '\0';
  162. #ifndef NO_PRINTF
  163.     Mach_MonPrintf(" %s ", component);
  164. #endif
  165.         /*
  166.          * Skip intermediate and trailing slashes so that *curCharPtr
  167.          * is Null when 'component' has the last component of the name.
  168.          */
  169.         while (*curCharPtr == '/') {
  170.             curCharPtr++;
  171.         }
  172.  
  173.     status = FsFindComponent(fsDomainPtr, curHandlePtr, component,
  174.                           &curHandlePtr);
  175.  
  176.     if (status != SUCCESS) {
  177. #ifndef NO_PRINTF
  178.         Mach_MonPrintf("<%x>\n", status);
  179. #endif
  180.         return(status);
  181.     }
  182.     }
  183.     *handlePtrPtr = curHandlePtr;
  184.     return status;
  185. }
  186.  
  187. /*
  188.  * ----------------------------------------------------------------------------
  189.  *
  190.  * Read --
  191.  *
  192.  *    Read from a file given its handle.
  193.  *
  194.  * Results:
  195.  *    A return status from the read.
  196.  *
  197.  * Side effects:
  198.  *    buffer is loaded with the data read in.
  199.  *    *readCountPtr is updated to reflect the number of bytes read.
  200.  *
  201.  * ----------------------------------------------------------------------------
  202.  */
  203. ReturnStatus
  204. Read(handlePtr, offset, numBytes, buffer, readCountPtr)
  205.     register Fsio_FileIOHandle     *handlePtr;
  206.     int            offset;
  207.     int            numBytes;
  208.     register Address    buffer;
  209.     int            *readCountPtr;
  210. {
  211.     int                firstBlock;
  212.     int                lastBlock;
  213.     int                lastByte;
  214.     BlockIndexInfo        indexInfo;
  215.     register    int        readSize;
  216.     register    int        blockAddr;
  217.     register    int        blockOffset;
  218.     register    int        bufferIndex;
  219.     register     ReturnStatus    status;
  220.     register    int        size;
  221.  
  222.     firstBlock = offset / FS_BLOCK_SIZE; 
  223.     lastByte = offset + numBytes - 1;
  224.     if (lastByte > handlePtr->descPtr->lastByte) {
  225.     lastByte = handlePtr->descPtr->lastByte;
  226.     }
  227.     lastBlock = lastByte / FS_BLOCK_SIZE;
  228.  
  229.     (void)FsGetFirstIndex(handlePtr, firstBlock, &indexInfo);
  230.  
  231.     bufferIndex = 0;
  232.     blockOffset = offset & FS_BLOCK_OFFSET_MASK;
  233. #ifdef SCSI0_BOOT 
  234.     Mach_MonPrintf(" read %d at %d into %x\n", numBytes, offset, buffer);
  235. #endif 
  236.  
  237.     while (indexInfo.blockNum <= lastBlock) {
  238.     if (indexInfo.blockNum < lastBlock) {
  239.         size = FS_BLOCK_SIZE - blockOffset;
  240.         readSize = FS_BLOCK_SIZE;
  241.     } else {
  242.         size = (lastByte & FS_BLOCK_OFFSET_MASK) + 1 - blockOffset;
  243.         readSize = size;
  244.     }
  245.     blockAddr = *indexInfo.blockAddrPtr + 
  246.     ((Ofs_DomainHeader *) fsDomainPtr->clientData)->dataOffset *
  247.         FS_FRAGMENTS_PER_BLOCK;
  248.     if (blockOffset != 0 || size != FS_BLOCK_SIZE) { 
  249.         status = FsDeviceBlockIO(FS_READ, &fsDevice, blockAddr,
  250.                (readSize - 1) / FS_FRAGMENT_SIZE + 1, readBuffer);
  251.         if (status != SUCCESS) {
  252.         goto readError;
  253.         }
  254.         bcopy(&(readBuffer[blockOffset]), &(buffer[bufferIndex]), size);
  255.     } else {
  256.         status = FsDeviceBlockIO(FS_READ, &fsDevice, blockAddr,
  257.             FS_FRAGMENTS_PER_BLOCK, &(buffer[bufferIndex]));
  258.         if (status != SUCCESS) {
  259.         goto readError;
  260.         }
  261.     }
  262.     bufferIndex += size;
  263.     blockOffset = 0;
  264.     FsGetNextIndex(handlePtr, &indexInfo);
  265.     }
  266.  
  267. readError:
  268.  
  269.     *readCountPtr = bufferIndex;
  270.  
  271.     return(status);
  272. }
  273.  
  274. /*
  275.  *----------------------------------------------------------------------
  276.  *
  277.  * FsFindComponent --
  278.  *
  279.  *
  280.  * Results:
  281.  *    None.
  282.  *
  283.  * Side effects:
  284.  *
  285.  *----------------------------------------------------------------------
  286.  */
  287. ReturnStatus
  288. FsFindComponent(domainPtr, curHandlePtr, component, newHandlePtrPtr)
  289.     Fsdm_Domain *domainPtr;
  290.     Fsio_FileIOHandle *curHandlePtr;
  291.     char *component;
  292.     Fsio_FileIOHandle **newHandlePtrPtr;
  293. {
  294.     register ReturnStatus status;
  295.     register int dirOffset;        /* Offset within the directory */
  296.     register int blockOffset;        /* Offset within a directory block */
  297.     register Fslcl_DirEntry *dirEntryPtr;    /* Reference to directory entry */
  298.     int length;                /* Length variable for read call */
  299.     register Fsio_FileIOHandle *handlePtr;
  300.  
  301.     dirOffset = 0;
  302.     do {
  303.     length = FSLCL_DIR_BLOCK_SIZE;
  304.     status = Read(curHandlePtr, dirOffset, length, readBuffer, &length);
  305.     if (status != SUCCESS) {
  306.         return(status);
  307.     }
  308.     if (length == 0) {
  309.         return(FS_FILE_NOT_FOUND);
  310.     }
  311.     dirEntryPtr = (Fslcl_DirEntry *)readBuffer;
  312.     blockOffset = 0;
  313.     while (blockOffset < FSLCL_DIR_BLOCK_SIZE) {
  314.         dirEntryPtr = (Fslcl_DirEntry *)((int)readBuffer + blockOffset);
  315.         if (dirEntryPtr->fileNumber != 0) {
  316.         /*
  317.          * A valid directory record.
  318.          */
  319. #ifndef NO_PRINTF
  320.         Mach_MonPrintf("Found %s\n", dirEntryPtr->fileName);
  321. #endif NO_PRINTF
  322.         if (strcmp(component, dirEntryPtr->fileName) == 0) {
  323.             handlePtr = (Fsio_FileIOHandle *)malloc(sizeof(Fsio_FileIOHandle));
  324.             FsInitFileHandle(domainPtr, dirEntryPtr->fileNumber,
  325.                     handlePtr);
  326.             *newHandlePtrPtr = handlePtr;
  327.             return(SUCCESS);
  328.         }
  329.         }
  330.         blockOffset += dirEntryPtr->recordLength;
  331.     }
  332.     dirOffset += FSLCL_DIR_BLOCK_SIZE;
  333.     } while(TRUE);
  334. }
  335.  
  336. /*
  337.  *----------------------------------------------------------------------
  338.  *
  339.  * FsInitFileHandle --
  340.  *
  341.  *    Initialize a file handle.
  342.  *
  343.  * Results:
  344.  *    None.
  345.  *
  346.  * Side effects:
  347.  *    Fills in the file handle that our caller has already allocated.
  348.  *
  349.  *----------------------------------------------------------------------
  350.  */
  351. void
  352. FsInitFileHandle(domainPtr, fileNumber, handlePtr)
  353.     Fsdm_Domain *domainPtr;
  354.     int fileNumber;
  355.     register Fsio_FileIOHandle *handlePtr;
  356. {
  357.     register Fsdm_FileDescriptor *descPtr;
  358.  
  359.     bzero((Address)handlePtr, sizeof(Fsio_FileIOHandle));
  360.     handlePtr->hdr.fileID.minor = fileNumber;
  361.     descPtr = (Fsdm_FileDescriptor *)malloc(sizeof(Fsdm_FileDescriptor));
  362.     FsGetFileDesc(domainPtr, fileNumber, descPtr);
  363.     handlePtr->descPtr = descPtr;
  364. }
  365.  
  366. /*
  367.  *----------------------------------------------------------------------
  368.  *
  369.  * FsGetFileDesc --
  370.  *
  371.  *    Read in a file descriptor from the disk.
  372.  *
  373.  * Results:
  374.  *    None.
  375.  *
  376.  * Side effects:
  377.  *    Fills in the file descriptor that our caller has already allocated.
  378.  *
  379.  *----------------------------------------------------------------------
  380.  */
  381. void
  382. FsGetFileDesc(domainPtr, fileNumber, descPtr)
  383.     Fsdm_Domain *domainPtr;
  384.     register int fileNumber;
  385.     register Fsdm_FileDescriptor *descPtr;
  386. {
  387.     register Ofs_DomainHeader *headerPtr;
  388.     register int         blockNum;
  389.     register int         offset;
  390.  
  391.     headerPtr = ((Ofs_DomainHeader *) domainPtr->clientData);
  392.     blockNum = headerPtr->fileDescOffset + fileNumber / FSDM_FILE_DESC_PER_BLOCK;
  393.     offset = (fileNumber & (FSDM_FILE_DESC_PER_BLOCK - 1)) *
  394.         FSDM_MAX_FILE_DESC_SIZE;
  395.  
  396.     (void)FsDeviceBlockIO(FS_READ, &fsDevice, 
  397.                blockNum * FS_FRAGMENTS_PER_BLOCK,
  398.                FS_FRAGMENTS_PER_BLOCK, readBuffer);
  399.     bcopy( readBuffer + offset, (char *) descPtr, sizeof(Fsdm_FileDescriptor));
  400. #ifndef NO_PRINTF
  401.     if (descPtr->magic != FSDM_FD_MAGIC) {
  402.     Mach_MonPrintf("desc %d bad <%x>\n", fileNumber, descPtr->magic);
  403.     }
  404. #endif
  405. }
  406. @
  407.  
  408.  
  409. 1.11
  410. log
  411. @got it to compile, moved location for sun3 kernel
  412. @
  413. text
  414. @d10 1
  415. a10 1
  416. static char rcsid[] = "$Header: /sprite/src/boot/sunprom/RCS/fs.c,v 1.10 90/07/17 15:42:24 mendel Exp Locker: jhh $ SPRITE (Berkeley)";
  417. d322 1
  418. a322 1
  419.     if (descPtr->magic != FS_FD_MAGIC) {
  420. @
  421.  
  422.  
  423. 1.10
  424. log
  425. @*** empty log message ***
  426. @
  427. text
  428. @d10 1
  429. a10 1
  430. static char rcsid[] = "$Header: /sprite/src/boot/scsiDiskBoot/RCS/fs.c,v 1.9 89/06/16 08:29:57 brent Exp $ SPRITE (Berkeley)";
  431. d16 1
  432. d37 1
  433. a37 1
  434.  * Fs_Open --
  435. d52 1
  436. a52 1
  437. Fs_Open(fileName, useFlags, permissions, handlePtrPtr)
  438. d111 1
  439. a111 1
  440.  * Fs_Read --
  441. d125 1
  442. a125 1
  443. Fs_Read(handlePtr, offset, numBytes, buffer, readCountPtr)
  444. d167 2
  445. a168 1
  446.             fsDomainPtr->headerPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK;
  447. d225 1
  448. a225 1
  449.     status = Fs_Read(curHandlePtr, dirOffset, length, readBuffer, &length);
  450. d308 1
  451. a308 1
  452.     register Fsdm_DomainHeader *headerPtr;
  453. d312 1
  454. a312 1
  455.     headerPtr = domainPtr->headerPtr;
  456. d320 1
  457. a320 1
  458.     bcopy( readBuffer + offset, descPtr, sizeof(Fsdm_FileDescriptor));
  459. @
  460.  
  461.  
  462. 1.9
  463. log
  464. @Updated to the new device interface
  465. @
  466. text
  467. @d10 1
  468. a10 1
  469. static char rcsid[] = "$Header: /sprite/src/boot/scsiDiskBoot/RCS/fs.c,v 1.8 89/01/06 08:14:31 brent Exp $ SPRITE (Berkeley)";
  470. a31 1
  471. #undef NO_PRINTF
  472. d55 1
  473. a55 1
  474.     FsLocalFileIOHandle     **handlePtrPtr;
  475. d58 1
  476. a58 1
  477.     FsLocalFileIOHandle *curHandlePtr;
  478. d104 1
  479. d125 1
  480. a125 1
  481.     register FsLocalFileIOHandle     *handlePtr;
  482. d153 1
  483. a153 1
  484. #ifdef notdef 
  485. d155 1
  486. a155 1
  487. #endif notdef 
  488. d208 2
  489. a209 2
  490.     FsDomain *domainPtr;
  491.     FsLocalFileIOHandle *curHandlePtr;
  492. d211 1
  493. a211 1
  494.     FsLocalFileIOHandle **newHandlePtrPtr;
  495. d216 1
  496. a216 1
  497.     register FsDirEntry *dirEntryPtr;    /* Reference to directory entry */
  498. d218 1
  499. a218 1
  500.     register FsLocalFileIOHandle *handlePtr;
  501. d222 1
  502. a222 1
  503.     length = FS_DIR_BLOCK_SIZE;
  504. d230 1
  505. a230 1
  506.     dirEntryPtr = (FsDirEntry *)readBuffer;
  507. d232 2
  508. a233 2
  509.     while (blockOffset < FS_DIR_BLOCK_SIZE) {
  510.         dirEntryPtr = (FsDirEntry *)((int)readBuffer + blockOffset);
  511. d238 1
  512. d240 1
  513. d242 1
  514. a242 1
  515.             handlePtr = (FsLocalFileIOHandle *)malloc(sizeof(FsLocalFileIOHandle));
  516. d251 1
  517. a251 1
  518.     dirOffset += FS_DIR_BLOCK_SIZE;
  519. d272 1
  520. a272 1
  521.     FsDomain *domainPtr;
  522. d274 1
  523. a274 1
  524.     register FsLocalFileIOHandle *handlePtr;
  525. d276 1
  526. a276 1
  527.     register FsFileDescriptor *descPtr;
  528. d278 1
  529. a278 1
  530.     bzero((Address)handlePtr, sizeof(FsLocalFileIOHandle));
  531. d280 1
  532. a280 1
  533.     descPtr = (FsFileDescriptor *)malloc(sizeof(FsFileDescriptor));
  534. d302 1
  535. a302 1
  536.     FsDomain *domainPtr;
  537. d304 1
  538. a304 1
  539.     register FsFileDescriptor *descPtr;
  540. d306 1
  541. a306 1
  542.     register FsDomainHeader *headerPtr;
  543. d311 3
  544. a313 3
  545.     blockNum = headerPtr->fileDescOffset + fileNumber / FS_FILE_DESC_PER_BLOCK;
  546.     offset = (fileNumber & (FS_FILE_DESC_PER_BLOCK - 1)) *
  547.         FS_MAX_FILE_DESC_SIZE;
  548. d318 1
  549. a318 1
  550.     bcopy( readBuffer + offset, descPtr, sizeof(FsFileDescriptor));
  551. @
  552.  
  553.  
  554. 1.8
  555. log
  556. @New include files and constants due to source reorganization
  557. @
  558. text
  559. @d9 2
  560. a10 2
  561. #ifndef lint
  562. static char rcsid[] = "$Header: fs.c,v 1.7 87/05/19 12:14:02 brent Exp $ SPRITE (Berkeley)";
  563. d14 2
  564. a15 4
  565. #include "fs.h"
  566. #include "fsDisk.h"
  567. #include "fsIndex.h"
  568. #include "fsOpTable.h"
  569. a17 7
  570.  * Things set up by Fs_AttachDisk
  571.  */
  572. extern    Fs_Device    fsDevice;
  573. extern    FsDomain    *fsDomainPtr;
  574. extern    FsHandle    *fsRootHandlePtr;
  575.  
  576. /*
  577. d32 1
  578. a32 1
  579.  
  580. d46 1
  581. a46 1
  582.  *    Calls Mem_Alloc
  583. d56 1
  584. a56 1
  585.     FsHandle     **handlePtrPtr;
  586. d59 1
  587. a59 1
  588.     FsHandle *curHandlePtr;
  589. d71 1
  590. a71 1
  591.     if (curHandlePtr->fileType != FS_DIRECTORY) {
  592. d84 1
  593. a84 1
  594.     Sys_Printf(" %s ", component);
  595. d99 1
  596. a99 1
  597.         Sys_Printf("<%x>\n", status);
  598. d125 1
  599. a125 1
  600.     register FsHandle     *handlePtr;
  601. d144 2
  602. a145 2
  603.     if (lastByte > handlePtr->lastByte) {
  604.     lastByte = handlePtr->lastByte;
  605. d154 1
  606. a154 1
  607.     Sys_Printf(" read %d at %d into %x\n", numBytes, offset, buffer);
  608. d168 1
  609. a168 1
  610.         status = FsBlockIO(FS_READ, &handlePtr->device, blockAddr,
  611. d173 1
  612. a173 1
  613.         Byte_Copy(size, &(readBuffer[blockOffset]), &(buffer[bufferIndex]));
  614. d175 1
  615. a175 1
  616.         status = FsBlockIO(FS_READ, &handlePtr->device, blockAddr,
  617. d209 1
  618. a209 1
  619.     FsHandle *curHandlePtr;
  620. d211 1
  621. a211 1
  622.     FsHandle **newHandlePtrPtr;
  623. d218 1
  624. a218 1
  625.     register FsHandle *handlePtr;
  626. d238 3
  627. a240 2
  628.         if (String_Compare(component, dirEntryPtr->fileName) == 0) {
  629.             handlePtr = (FsHandle *)Mem_Alloc(sizeof(FsHandle));
  630. d272 1
  631. a272 1
  632.     register FsHandle *handlePtr;
  633. d276 3
  634. a278 3
  635.     Byte_Zero(sizeof(FsHandle), (Address)handlePtr);
  636.     handlePtr->fileNumber = fileNumber;
  637.     descPtr = (FsFileDescriptor *)Mem_Alloc(sizeof(FsFileDescriptor));
  638. a280 3
  639.     handlePtr->device = fsDevice;
  640.     handlePtr->fileType = descPtr->fileType;
  641.     handlePtr->lastByte = descPtr->lastByte;
  642. d313 1
  643. a313 1
  644.     (void)FsBlockIO(FS_READ, &headerPtr->device, 
  645. d316 1
  646. a316 1
  647.     Byte_Copy(sizeof(FsFileDescriptor), readBuffer + offset, descPtr);
  648. d319 1
  649. a319 1
  650.     Sys_Printf("desc %d bad <%x>\n", fileNumber, descPtr->magic);
  651. @
  652.  
  653.  
  654. 1.7
  655. log
  656. @More trimming to save space.  The Index operations always return
  657. SUCCESS so there's no need to check their return code.
  658. @
  659. text
  660. @d10 1
  661. a10 1
  662. static char rcsid[] = "$Header: fs.c,v 1.6 87/05/11 11:16:35 brent Exp $ SPRITE (Berkeley)";
  663. a14 1
  664. #include "fsInt.h"
  665. a15 1
  666. #include "fsLocalDomain.h"
  667. d80 1
  668. a80 1
  669.     if (curHandlePtr->rec.fileType != FS_DIRECTORY) {
  670. d153 2
  671. a154 2
  672.     if (lastByte > handlePtr->rec.lastByte) {
  673.     lastByte = handlePtr->rec.lastByte;
  674. d177 1
  675. a177 1
  676.         status = FsBlockIO(FS_READ, &handlePtr->rec.device, blockAddr,
  677. d184 1
  678. a184 1
  679.         status = FsBlockIO(FS_READ, &handlePtr->rec.device, blockAddr,
  680. d285 1
  681. a285 1
  682.     handlePtr->rec.fileID.fileNumber = fileNumber;
  683. d288 4
  684. a291 4
  685.     handlePtr->nameToken = (ClientData)descPtr;
  686.     handlePtr->rec.device = fsDevice;
  687.     handlePtr->rec.fileType = descPtr->fileType;
  688.     handlePtr->rec.lastByte = descPtr->lastByte;
  689. @
  690.  
  691.  
  692. 1.6
  693. log
  694. @Trimmed down version that works.
  695. @
  696. text
  697. @d10 1
  698. a10 1
  699. static char rcsid[] = "$Header: fs.c,v 1.5 87/05/08 17:44:41 brent Exp $ SPRITE (Berkeley)";
  700. d160 1
  701. a160 4
  702.     status = FsGetFirstIndex(handlePtr, firstBlock, &indexInfo);
  703.     if (status != SUCCESS) {
  704.     return(status);
  705.     }
  706. d314 1
  707. a314 1
  708.     int fileNumber;
  709. @
  710.  
  711.  
  712. 1.5
  713. log
  714. @Updated to reflect new fs data structures (handle changed)
  715. @
  716. text
  717. @d10 1
  718. a10 1
  719. static char rcsid[] = "$Header: fs.c,v 1.4 86/07/24 11:32:59 brent Exp $ SPRITE (Berkeley)";
  720. d72 1
  721. d89 1
  722. d91 1
  723. a91 3
  724.             component[index] = *curCharPtr;
  725.             index++;
  726.             curCharPtr++;
  727. d93 4
  728. a96 1
  729.         component[index] = '\0';
  730. d109 3
  731. d333 1
  732. d337 1
  733. @
  734.  
  735.  
  736. 1.4
  737. log
  738. @Completed Fs_Read (there were a number of bugs.)
  739. @
  740. text
  741. @d10 1
  742. a10 1
  743. static char rcsid[] = "$Header: fs.c,v 1.3 86/07/21 09:35:02 brent Exp $ SPRITE (Berkeley)";
  744. d81 1
  745. a81 1
  746.     if (curHandlePtr->fileType != FS_DIRECTORY) {
  747. a127 1
  748.  
  749. d149 2
  750. a150 2
  751.     if (lastByte > handlePtr->lastByte) {
  752.     lastByte = handlePtr->lastByte;
  753. d176 1
  754. a176 1
  755.         status = FsBlockIO(FS_READ, &handlePtr->device, blockAddr,
  756. d183 1
  757. a183 1
  758.         status = FsBlockIO(FS_READ, &handlePtr->device, blockAddr,
  759. d284 1
  760. a284 1
  761.     handlePtr->fileID.fileNumber = fileNumber;
  762. d287 4
  763. a290 4
  764.     handlePtr->domainToken = (ClientData)descPtr;
  765.     handlePtr->device = fsDevice;
  766.     handlePtr->fileType = descPtr->fileType;
  767.     handlePtr->lastByte = descPtr->lastByte;
  768. @
  769.  
  770.  
  771. 1.3
  772. log
  773. @Added stuf for Fs_Open
  774. @
  775. text
  776. @d10 1
  777. a10 1
  778. static char rcsid[] = "$Header: fs.c,v 1.2 86/07/18 11:58:21 nelson Exp $ SPRITE (Berkeley)";
  779. d150 3
  780. d162 3
  781. d171 1
  782. a171 1
  783.         size = lastByte & FS_BLOCK_OFFSET_MASK + 1;
  784. d182 1
  785. a182 1
  786.         Byte_Copy(size, &(readBuffer[blockOffset]), buffer);
  787. d226 1
  788. a226 1
  789.     int length;            /* Length variable for read call */
  790. d257 1
  791. d287 1
  792. a287 1
  793.     FsGetFileDesc(fsDomainPtr, fileNumber, descPtr);
  794. d291 1
  795. d328 3
  796. @
  797.  
  798.  
  799. 1.2
  800. log
  801. @Trimmed.
  802. @
  803. text
  804. @d10 1
  805. a10 1
  806. static char rcsid[] = "$Header: fs.c,v 1.1 86/07/18 09:32:17 brent Exp $ SPRITE (Berkeley)";
  807. d17 1
  808. d19 1
  809. d21 10
  810. a30 1
  811. extern    FsDomainHeader    *fsDomainPtr;
  812. d33 11
  813. d48 67
  814. d169 1
  815. a169 1
  816.             fsDomainPtr->dataOffset * FS_FRAGMENTS_PER_BLOCK;
  817. d171 1
  818. a171 1
  819.         status = FsBlockIO(handlePtr, blockAddr,
  820. d178 2
  821. a179 2
  822.         status = FsBlockIO(handlePtr, blockAddr, FS_FRAGMENTS_PER_BLOCK,
  823.                  &(buffer[bufferIndex]));
  824. d194 126
  825. @
  826.  
  827.  
  828. 1.1
  829. log
  830. @Initial revision
  831. @
  832. text
  833. @d10 1
  834. a10 1
  835. static char rcsid[] = "$Header: vmSunBoot.c,v 1.9 86/05/01 23:20:11 nelson Exp $ SPRITE (Berkeley)";
  836. d19 1
  837. d42 5
  838. a46 5
  839.     register    FsHandle    *handlePtr;
  840.     int        offset;
  841.     int        numBytes;
  842.     Address    buffer;
  843.     int        *readCountPtr;
  844. d48 10
  845. a57 9
  846.     int            firstBlock;
  847.     int            lastBlock;
  848.     int            lastByte;
  849.     ReturnStatus    status;
  850.     BlockIndexInfo    indexInfo;
  851.     int            bufferIndex;
  852.     int            blockOffset;
  853.     int            size;
  854.     int            readSize;
  855. d79 2
  856. d82 1
  857. a82 1
  858.         status = FsFileBlockIO(handlePtr, indexInfo.blockAddr,
  859. d89 1
  860. a89 2
  861.         status = FsFileBlockIO(handlePtr, indexInfo.blockAddr,
  862.                  FS_FRAGMENTS_PER_BLOCK,
  863. @
  864.